Experimental BBS Explossion 3/Experimental BBS Explossion III.iso/sound/driver.zip/MIDI.ASM

Assembly Source File | 1987-05-11 | 38KB | 1,065 lines

page 58,132
;    file: MIDI.ASM
TITLE    Z8470 MIDI driver for MSDOS
SUBTTL    DESCRIPTION
;THINGS TO ADD: (DELETE THESE LINES AS YOU IMPLIMENT THEM)
;data errors reported at the time you get to that byte in read buffer
;
;
;    Loadable midi device driver for msdos.
;    Written by: Mike Higgins
;    Copyright (c) April 1984 by The Computer Entomologist.
;
;************************************************************************
;    This file implements an interrupt driven character device driver
;for the midi board described in the article: "A MIDI Project", by Jay
;Kupicky, BYTE Magazine, June 1986, V.11 N.6.  The driver will work on any
;similar board that uses the Z8470 Z80 DART chip.  This code should work
;with several DART chips on one board, if you change the appropriate
;counters, add structures and buffers for each UART, and check the interrupt
;and initialization code.
;    Why write or use such a driver?  Because the code written by
;Jay Kubicky could only be compiled on one specific C compiler, and
;required non-standard communication channels between the main code and
;the assembly driver.
;    This driver implements the MIDI board as a standard MSDOS character
;device that can be called from any program written in any language.  Even
;interpretative BASIC can open this device and perform any function that
;the board is capable of.  All the communication with the driver is
;done with standard reads,writes, and IOCTL calls.  The character input/
;output is the MIDI data, and the IOCTL data allows a program to find the
;state of the MIDI UARTS, and to perform initialization functions. (Test
;for data available or error status, flush buffers, change echo/thru
;modes).   Additionally, there is a read-with-timeout feature that
;allows the driver to return to you if no data arrives after a specified
;number of milliseconds.
;    This driver implements a 128 byte buffer on input and output to
;make catching all the MIDI data as easy as possible for you programs.
;The output buffer allows your programs to send multiple byte commands
;without having to wait on each byte: your processing can continue while
;the driver sends the bytes out one at a time for you.
;    There is also a "MIDI out/through" option in this driver that
;will copy, if enabled, any incoming bytes immediately to the associated
;MIDI out port.  I call this a "poor man's MIDI merge" because it will
;scramble MIDI commands together if they arrive at the output buffer
;too close together.  But it does have some limited applications.  Note
;that a very intelligent MIDI merge program would be easy to write as an
;application on top of this board and driver.  (Requires both UARTs hooked
;up with MIDI drivers and receivers, like mine is).
;    While initializing the uarts, this driver also initializes the on
;board clock chip.  You can get direct access to this clock for timing midi
;events, and the driver uses this clock to count time for the read-with-
;timeout feature.  The delta times are in "digital" milliseconds, so the
;value changes 1024 times each second. The two byte clock value from timer2
;will allow you to time anything that is 64 seconds or less, which should be
;long enough for any typical MIDI use. (You will have to store delta times,
;not absolute time).  On my version of the board, timer2 overflows into
;timer3, so this can be considered a 16bit extension of the regular timer.
;This results in a four byte clock that only overflows after 136
;years.  If you can keep your PC running continuously that long (without
;re-booting) I'll be very impressed!
;
;************************************************************************
;
;    Permission is hereby granted to use or distribute this software
;without any restrictions.  You may make copies for yourself or your
;friends. You may include it in any hardware or software product that you
;sell for profit.
;
;    This software is distributed as is, and is not guaranteed to work
;on any particular hardware/software configuration.  Furthermore, no
;liability is granted with this software: the user takes responsibility for
;any damage this software may do to his system.
;
;    Nasty notices aside, if you have any questions about this software,
;you can reach me at the address below.  If you implement any new features or
;find (and fix!) any bugs, I would be happy to hear from you.
;
;    Mike Higgins
;    The Computer Entomologist
;    P.O. Box 197
;    Duncans Mills, CA 95430
;
;
;        ASSEMBLY INSTRUCTIONS:
;    MASM MIDI,MIDI,MIDI,NUL
;    LINK MIDI,MIDI,MIDI,NUL
;    EXE2BIN MIDI
;    COPY MIDI.BIN A:    (IF NOT THERE ALREADY)
;        ADD THE FOLLOWING LINE TO A:CONFIG.SYS:
;    DRIVER=MIDI.BIN
;        RE-BOOT YOUR SYSTEM AND IT'S THERE!
;
;    NOTE:
;
;    There are  hooks in the driver for features that do not work
;    yet.  So don't expect all of these things to work just
;    because there are comments about them or bits to set for them.
;    Write me if you do implement any of this stuff.
SUBTTL    DEFINITIONS
PAGE
;
;        DEVICE TYPE CODES
DEVCHR    EQU    08000h    ;THIS IS A CHARACTER DEVICE
DEVBLK    EQU    0H    ;THIS IS A BLOCK (DISK) DEVICE
DEVIOC    EQU    04000H    ;THIS DEVICE ACCEPTS IOCTRL REQUESTS
DEVNON    EQU    02000H    ;NON IBM DISK DRIVER
DEVSPC    EQU    010H    ;CONSOLE ACCEPTS SPECIAL INTERUPT 29
DEVCLK    EQU    08H    ;THIS IS THE CLOCK DEVICE
DEVNUL    EQU    04H    ;THIS IS THE NUL DEVICE
DEVSTO    EQU    02H    ;THIS IS THE CURRENT STANDARD OUTPUT DEVICE
DEVSTI    EQU    01H    ;THIS IS THE STANDARD INPUT DEVICE
;
;        ERROR STATUS BITS
STSERR    EQU    08000H    ;GENERAL ERROR, SEE LOWER ORDER BITS FOR REASON
STSBSY    EQU    0200H    ;DEVICE IS BUISY
STSDNE    EQU    0100H    ;REQUEST IS COMPLETED
;        ERROR REASON VALUES FOR LOWER ORDER BITS.
ERRWP    EQU    0    ;WRITE PROTECT ERROR
ERRUU    EQU    1    ;UNKNOWN UNIT
ERRDNR    EQU    2    ;DRIVE NOT READY
ERRUC    EQU    3    ;UNKNOWN COMMAND
ERRCRC    EQU    4    ;CYCLIC REDUNDANCY CHECK ERROR
ERRBSL    EQU    5    ;BAD DRIVE REQUEST STRUCTURE LENGTH
ERRSL    EQU    6    ;SEEK ERROR
ERRUM    EQU    7    ;UNKNOWN MEDIA
ERRSNF    EQU    8    ;SECTOR NOT FOUND
ERRPOP    EQU    9    ;PRINTER OUT OF PAPER
ERRWF    EQU    10    ;WRITE FAULT
ERRRF    EQU    11    ;READ FAULT
ERRGF    EQU    12    ;GENERAL FAILURE
;
;
;        DEFINE THE PORT OFFSETS AND IMPORTANT BOARD CONSTANTS
MIDDAT    EQU    0    ;DATA REGESTER
MIDCON    EQU    2    ;CONTROL REGESTER
MIDB    EQU    1    ;BITS TO FORCE IO ADDRESS TO UART B WITH OR
MIDA    EQU    NOT MIDB    ;MASK TO FORCE IO ADDR TO UART A WITH AND
;
;        BIT ASSIGNMENTS FOR THE STATUS WORD IN EACH UNIT STRUCTURE
OUTINT    EQU    1    ;CHARACTER SENT OUT, INTERUPT SHOULD BE COMMING
OUTHRU    EQU    2    ;INPUT IS ECHOED THRU OUTPUT (POOR MANS MIDI OUT/THRU
;
;        BIT ASSIGNMENTS FOR THE ERVAL WORD IN EACH UNIT STRUCTURE
ERITMO    EQU    1    ;INPUT TIMEOUT ERROR
EROTMO    EQU    2    ;OUTPUT TIMEOUT ERROR
ERIBFO    EQU    4    ;INPUT BUFFER OVERFLOW
EROBFO    EQU    8    ;OUPUT BUFFER OVERFLOW
ERPARE    EQU    10H    ;PARITY ERROR (NOT ENABLED)
ERFRAM    EQU    20H    ;FRAMING ERROR
ERRXOV    EQU    40H    ;RECEVER OVERRUN (NOT LIKELY)
;
;BIT DEFINITIONS FOR ALL THE BITS/REGESTERS IN THE Z8470 ZILOG Z80 DART CHIP
;
    ;WRITE REGESTER 0 BITS
ZRESET    EQU    010H    ;RESET EXT/STATUS INTERUPTS
ZCHANR    EQU    018H    ;CHANNEL RESET
ZRXINT    EQU    020H    ;ENABLE INT ON NEXT Rx CHARACTER
ZTXINT    EQU    028H    ;RESET Tx INT PENDING
ZERRES    EQU    030H    ;ERROR RESET
ZREINT    EQU    038H    ;RETURN FROM INT (CHANNEL A ONLY)
    ;WRITE REGESTER 1 BITS
W1EXTI    EQU    001H    ;EXT INT ENABLE
W1TXINT    EQU    002H    ;Tx INT ENABLE
W1STAT    EQU    004H    ;STATUS EFFECTS VECTOR (CHANNEL B ONLY)
W1RXDIS    EQU    000H    ;Rx INT DISABLE
W1RX1ST    EQU    008H    ;Rx INT ON FIRST CHARACTER
W1RXALP    EQU    010H    ;Rx INT ON ALL CHARACTERS (PARITY AFFECTS VECTOR)
W1RXALL    EQU    018H    ;Rx INT ON ALL CHARACTERS (PARITY DOESN'T AFF. VEC)
W1WAITR    EQU    020H    ;WAIT/READY ON R/T
W1WAITF    EQU    040H    ;WAIT/READY FUNCTION
W1WAITE    EQU    080H    ;WAIT/READY ENABLE
    ;WRITE REGESTER 3 BITS
W3RXEN    EQU    001H    ;Rx ENABLE
W3AUTO    EQU    020H    ;AUTO ENABLES
W3RX5    EQU    000H    ;Rx 5 BITS/CHAR
W3RX7    EQU    040H    ;Rx 7 BITS/CHAR
W3RX6    EQU    080H    ;Rx 6 BITS/CHAR
W3RX8    EQU    0C0H    ;Rx 8 BITS/CHAR
    ;WRITE REGESTER 4 BITS
W4PARE    EQU    001H    ;PARITY ENABLE
W4PEVN    EQU    002H    ;PARITY IS EVEN
W4PODD    EQU    000H    ;PARITY IS ODD
W4STOP1    EQU    004H    ;ONE STOP BITS
W4STP15    EQU    008H    ;1.5 STOP BITS
W4STOP2    EQU    00CH    ;TWO STOP BITS
W4X1    EQU    000H    ;X1 CLOCK MODE
W4X16    EQU    040H    ;X16 CLOCK MODE
W4X32    EQU    080H    ;X32 CLOCK MODE
W4X64    EQU    0C0H    ;X64 CLOCK MODE
    ;WRITE REGESTER 5 BITS
W5RTS    EQU    002H    ;SET RTS BIT IN OUTPUT
W5TXEN    EQU    008H    ;Tx ENABLE
W5BREAK    EQU    010H    ;SEND BREAK
W5TX5    EQU    000H    ;Tx 5 BITS/CHARACTER
W5TX7    EQU    020H    ;Tx 7 BITS/CHAR
W5TX6    EQU    040H    ;Tx 6 BITS/CHAR
W5TX8    EQU    060H    ;Tx 8 BITS/CHAR
W5DTR    EQU    080H    ;SET DTR BIT IN OUTPUT
    ;READ REGESTER 0 BITS
RXCHAR    EQU    001H    ;CHARACTER HAS BEEN RECEIVED
INTPEND    EQU    002H    ;INTERUPT IS PENDING (CHANNEL A ONLY)
TXFREE    EQU    004H    ;Tx BUFFER IS EMPTY
CD    EQU    008H    ;CARRIER DETECT LINE IS ON
RI    EQU    010H    ;RING INDICATOR LINE IS ON
CTS    EQU    020H    ;CLEAR TO SEND LINE IS ON
BREAK    EQU    080H    ;BREAK HAS BEEN DETECTED
    ;READ REGESTER 1 BITS
R1ALL    EQU    001H    ;ALL SENT (Tx BUFFER?)
R1PERR    EQU    010H    ;PARRITY ERROR
R1RXOVR    EQU    020H    ;Rx OFERRUN ERROR
R1FRAME    EQU    040H    ;FRAMING ERROR
    ;READ REGESTER 2 BITS
VECMASK    EQU    006H    ;REASON-FOR-INTERUPT BITS
VECB    EQU    008H    ;UART B FIRED INTERUPT
;
    ;REGESTER OFFSETS AND BIT ASSIGNMENTS FOR THE CLOCK TIMER CHIP
TIMER1    EQU    -3    ;OFFSET FROM CONTROL REGESTER TO TIMER DATA 1
TIMER2    EQU    -2    ;TIMER 2 DATA REGESTER
TIMER3    EQU    -1    ;TIMER 3
T1    EQU    0    ;CONTROLLER TIMER 1 SELECT VALUE
T2    EQU    040H    ;SELECT TIMER 2
T3    EQU    080H    ;SELECT TIMER 3
LMSB    EQU    030H    ;READ TIMER REGESTERS IN LITTLE ENDIAN MODE
SHOOT    EQU    002H    ;ONE SHOT MODE
RATE    EQU    004H    ;RATE GENERATOR MODE
SQUARE    EQU    006H    ;SQUARE WAVE MODE
LATCH    EQU    0    ;LATCH THE CURRENT VALUES FOR READING
;
SUBTTL    DRIVER LIST HEAD
PAGE
;*************************************************************************
;
;    BEGENING OF DRIVER CODE.
;
DRIVER    SEGMENT
    ASSUME    CS:DRIVER,DS:DRIVER,ES:DRIVER
;    ORG    0    ;DRIVERS START AT 0
MIDIB:
    DW    MIDIA,-1    ;POINTER TO NEXT DEVICE: DOS FILLS IN SEG.
    DW    DEVCHR OR DEVIOC    ;CHARACTER DEVICE, IOCTL ALLOWED
    DW    STRATEGY        ;OFFSET TO STRATEGY ROUTINE.
    DW    REQUESTB        ;OFFSET TO "INTERUPT" ENTRYPOINT.
    DB    "MIDIB   "        ;DEVICE NAME.
MIDIA:
    DW    -1,-1        ;POINTER TO NEXT DEVICE: END OF LINKED LIST.
    DW    DEVCHR OR DEVIOC    ;THIS DEVICE IS CHARACTER IOCTL
    DW    STRATEGY        ;STRATEGY ROUTINE
    DW    REQUESTA        ;I/O REQUEST ROUTINT
    DB    "MIDIA   "

debug    dd    0b0000000h
notify    macro    char
;        local   store
;    push    es
;    push    di
;    push    ax
;    mov    al,'&char'
;    les    di,CS:debug
;    stos    byte ptr [di]
;    inc    di
;        cmp     di,80*25*2
;        jl      store
;        xor     di,di
;store:
;        mov    word ptr CS:debug,di
;        mov     al,'<'
;        stos    byte ptr es:[di]
;    pop    ax
;    pop    di
;    pop    es
endm

SUBTTL DRIVER INTERNAL DATA STRUCTURES
PAGE
;
MIDI_UNITS    EQU    2    ;NUMBER OF UNITS THIS DRIVER IS BUILT FOR
MIDI_VEC    DW    028H    ;INTERUPT VECTOR ADDRESS (NOT VECTOR NUMBER)
CLOCK_PORT    DW    0FFA7H    ;PORT OF CLOCK CONTROL REGESTER
;
UNIT    STRUC    ;EACH UNIT HAS A STRUCTURE DEFINING IT'S STATE:
PORT    DW    ?    ;I/O PORT ADDRESS
STATUS    DW    ?    ;STATUS BITS
TIMEOUT    DW    ?    ;TIMEOUT CONSTANT ON READ OR WRITE REQUEST
ERVAL    DW    ?    ;BIT ENCODED ERRORS SINCE LAST YOU LOOKED
EROFF    DW    ?    ;OFFSET TO FIRST CHARACTER AFTER ERROR
IFIRST    DW    ?    ;OFFSET TO FIRST CHARACTER IN INPUT BUFFER.
IAVAIL    DW    ?    ;OFFSET TO NEXT AVAILABLE BYTE.
IBUF    DW    ?    ;POINTER TO 128 BYTE INPUT BUFFER.
OFIRST    DW    ?    ;OFFSET INTO FIRST CHARACTER IN OUTPUT BUFFER
OAVAIL    DW    ?    ;OFFSET INTO NEXT AVAIL BYTE IN OUTPUT BUFFER
OBUF    DW    ?    ;POINTER TO 128 BYTE OUTPUT BUFFER
UNIT    ENDS

;        TABLE OF STRUCTURES FOR EACH MIDI UNIT
;    THE STRUCTURES FOR ALL THE UARTS MUST BE ORGANIZED TOGETHER INTO
;    A CONTIGUOUS TABLE, BECAUSE THE INTERUPT SERVICE ROUTINE SCANS
;    THROUGH THEM WHILE DETERMINING WHICH DART FIRED THE INTERUPT.
;    SIMILARLY, THE STRUCTURES FOR THE TWO UARTS IN EACH DART MUST BI
;    IN A-B ORDER IN THIS TABLE.
;
MIDI_TABA:
    UNIT    <0FFA0H,0,-1,0,-1,0,0,INABUF,0,0,OUTABUF>
UNIT_SIZE    EQU    $-MIDI_TABA
MIDI_TABB:
    UNIT    <0FFA1H,0,-1,0,-1,0,0,INBBUF,0,0,OUTBBUF>

        ;IF THE BUFFER SIZE IS A POWER OF TWO, THE PROCESS OF KEEPING
        ;THE OFSETTS WITHIN THE BOUNDS OF THE BUFFER IS GREATLY
        ;SIMPLIFIED.  IF YOU MODIFY THE BUFFER SIZE, KEEP IT A
        ;POWER OF 2, AND MODIFY THE MASK ACCORDINGLY.
BUFSIZ    EQU    128        ;INPUT BUFFER SIZE
BUFMSK    EQU    127        ;MASK FOR CALCULATING OFFSETS MODULO BUFSIZ
INABUF    DB    BUFSIZ DUP (?)
INBBUF    DB    BUFSIZ DUP (?)
OUTABUF    DB    BUFSIZ DUP (?)
OUTBBUF    DB    BUFSIZ DUP (?)
;
;    STRUCTURE OF AN I/O REQUEST PACKET STATIC HEADER
;
PACK    STRUC
LEN    DB    ?    ;LENGTH OF RECORD
PRTNO    DB    ?    ;UNIT CODE
CODE    DB    ?    ;COMMAND CODE
STAT    DW    ?    ;RETURN STATUS
DOSQ    DD    ?    ;UNUSED DOS QUE LINK POINTER
DEVQ    DD    ?    ;UNUSED DRIVER QUE LINK POINTER
MEDIA    DB    ?    ;MEDIA CODE ON READ/WRITE
XFER    DW    ?    ;XFER ADDRESS OFFSET
XSEG    DW    ?    ;XFER ADDRESS SEGMENT
COUNT    DW    ?    ;TRANSFER BYTE COUNT.
PACK    ENDS
;
;    THE FOLLOWING TWO WORDS IS THE STORAGE AREA FOR THE REQUEST PACKET
;    ADDRESS, SENT TO ME BY A STRATEGY ROUTINE CALL.
;        AS REQUESTED BY THE MSDOS DRIVER MANUAL, I AM "THINKING
;    ABOUT" THE FUTURE, SO I`M DESIGNATING THIS POINTER AS THE QUEUE
;    LIST HEAD FOR REQUESTS TO THIS DRIVER.
;
PACKHEAD    DD    0
;
;    THE STRATEGY ROUTINE ITSELF.
    PUBLIC    STRATEGY
STRATEGY    PROC    FAR
            ;SQUIRREL AWAY THE POINTER FOR LATER.
    MOV    WORD PTR CS:PACKHEAD,BX        ;STORE THE OFFSET,
    MOV    WORD PTR CS:PACKHEAD+2,ES    ;AND THE SEGMENT.
    RET
STRATEGY    ENDP
SUBTTL    REQUEST ROUTINES
PAGE

;        I/O REQUEST ROUTINES
    PUBLIC    REQUESTA
REQUESTA:        ;MIDIA HAS BEEN REQUESTED
    PUSH    SI    ;SAVE SI SO YOU CAN
    MOV    SI,OFFSET MIDI_TABA    ;GET THE DEVICE UNIT TABLE ADDRESS.
    JMP    GEN_REQUEST    ;THE GENERIC DRIVER DOES THE REST.
REQUESTB:        ;MIDIB HAS BEEN REQUESTED TO DO SOMETHING
    PUSH    SI    ;SAVE SI
    MOV    SI,OFFSET MIDI_TABB    ;GET UNIT TABLE TWO`S ADDRESS

GEN_REQUEST:
        PUSHF        ;I REQUIRE DIRECTION FLAG CLEARED, SO I SAVE
    CLD        ;THE FLAGS AND CLEAR THEM HERE.
    PUSH    AX        ;SAVE ALL THE REGESTERS, YOU MAY NOT
    PUSH    BX        ;NEED THEM ALL, BUT YOU WILL REGRET IT
    PUSH    CX        ;IF YOU FORGET TO SAVE JUST ONE OF THEM.
    PUSH    DX
    PUSH    DI
    PUSH    BP
    PUSH    DS
    PUSH    ES

    PUSH    CS        ;COPY THE CS REGESTER
    POP    DS        ;INTO THE DS TO ACCESS MY DATA
    LES    BX,PACKHEAD    ;RECOVER THE POINTER TO THE PACKET.
    MOV    AL,ES:CODE[BX]    ;GET THE FUNCTION REQUEST CODE,
    MOV    AH,0        ;MAKE IT INTO A WORD,
    SAL    AX,1        ;CONVERT TO A WORD OFFSET,
    MOV    DI,AX        ;AND ADD TO THE TABLE START ADDRESS
    MOV    AX,STSERR OR ERRUC    ;SEND UNKNOWN COMMAND ERROR FOR EXIT
    JMP    MIDI_FUNCS[DI]        ;JUMP TO THE APPROPRIATE ROUTINE
;
;        TABLE OF OFFSETS TO ALL THE DRIVER FUNCTIONS
;
MIDI_FUNCS DW    MIDI_INIT    ;INITIALIZE DRIVER
    DW    EXIT        ;MEDIA CHECK (BLOCK DEVICES ONLY)
    DW    EXIT        ;BUILD BPB (BLOCK DEVICES ONLY)
    DW    IOCTLIN        ;IOCTL INPUT
    DW    READ        ;READ
    DW    EXIT        ;NON-DESTRUCTIVE READ
    DW    EXIT        ;INPUT STATUS
    DW    EXIT        ;FLUSH INPUT BUFFER
    DW    WRITE        ;WRITE
    DW    WRITE        ;WRITE WITH VERIFY
    DW    EXIT        ;OUTPUT STATUS
    DW    EXIT        ;FLUSH OUTPUT BUFFER
    DW    IOCTLOUT    ;IOCTL OUTPUT
;
;    EXIT FROM DRIVER REQUEST
;        CALL WITH AX= RETURN STATUS VALUE
EXITP    PROC    FAR
EXIT:
    LES    BX,PACKHEAD    ;RETREIVE POINTER TO PACKET
;    OR    AX,STSDNE    ;SET THE DONE BIT IN IT.
    MOV    ES:STAT[BX],AX    ;STORE THE STATUS BACK IN THE PACKET.

    POP    ES        ;RESTORE ALL THE REGESTERS
    POP    DS
    POP    BP
    POP    DI
    POP    DX
    POP    CX
    POP    BX
    POP    AX
    POPF
    POP    SI
    RET
EXITP    ENDP
SUBTTL    READ DATA REQUEST ROUTINE
PAGE
;
;        ALL THE FOLLOWING ROUTINES ARE CALLED WITH THE SAME CONTEXT
;    FROM THE REQUEST ROUTINE:
;    - ES:BX POINTS TO THE I/O PACKET.
;       ROUTINES CAN MUCK UP THESE TWO REGESTERS IF THEY WANT, AS EXIT
;       WILL RESTORE THEM BEFORE IT TRIES TO SEND THE STATUS WORD BACK.
;    - CS: AND DS: POINT TO THE BEGENING OF THE DRIVER SEGMENT.
;    - DS:SI POINTS TO THE DEVICE UNIT TABLE DESCRIBING THE PARTICULAR
;       PORT BEING ACCESSED.
;    - ALL OTHER REGESTERS ARE AVAILABLE FOR USE, THE EXIT ROUTINE
;       RESTORES THEM ALL BEFORE RETURNING TO MSDOS.
;        ALL THE FOLLOWING ROUTINES SHOULD EXIT BY DOING A JMP
;    TO THE EXIT ROUTINE.  EXIT ASSUMES THAT AX
;    CONTAINS EITHER ZERO, OR THE ERROR BIT SET AND A VALID ERROR
;    RETURN VALUE IN THE LOW ORDER BITS.  EXIT SETS THE DONE BIT IN
;    THIS VALUE FOR YOU BEFORE IT RETURNS TO MSDOS.
;
SUBTTL    READ REQUEST ROUTINE
;        READ DATA FROM DEVICE
;
READ:
    CALL    GET_CLOCK        ;GET CLOCK CURRENT VALUE FOR READ-
    MOV    DX,AX            ;WITH-TIMEOUT TEST, AND STORE IT IN DX
    MOV    CX,ES:COUNT[BX]        ;GET THE REQUESTED NUMBER OF BYTES
    LES    DI,DWORD PTR ES:XFER[BX] ;DI IS OFFSET TO USER BUFFER
    MOV    BX,TIMEOUT[SI]        ;GET THE TIMEOUT LIMIT.
RLUP:
    MOV    AX,EROFF[SI]        ;CHECK TO SEE IF IT'S TIME
    CMP    AX,IFIRST[SI]        ;TO REPORT AN ERROR
    JE    ERR_READ
    CALL    GET_IN            ;GET NEXT CHAR FROM INPUT BUFFER
    CMP    AH,0            ;WAS THERE ONE?
    JNE    READ_WAIT        ;NO, TEST FOR TIMEOUT
    STOS    BYTE PTR[DI]        ;YES,WRITE THIS BYTE OUT
        ;ALTHOUGH MSDOS NEVER, TO MY KNOWLEDGE, ASKS FOR MORE THAN
        ;ONE STUPID CHARACTER AT A TIME, I LOOP ON THE REQUEST SIZE
        ;SO THAT THIS DRIVER WILL STILL WORK ON THAT GLORIOUS DAY
        ;WHEN SOMEBODY ASKS FOR MORE THAN ONE.
    LOOP    RLUP            ;KEEP GOING IF YOU WERE REQUESTED.
    MOV    AX,STSDNE        ;RETURN NO ERRORS IN AX IF DONE.
    JMP    EXIT
ERR_READ:            ;NOW IS THE TIME TO REPORT AN INPUT ERROR
    MOV    AX,-1            ;DISABLE THE ERROR CHECKING BY
    MOV    EROFF[SI],AX        ;SETTING OFFSET TO FFFF
    OR    ERVAL[SI],ERIBFO    ;SET INPUT BUFFER OVERFLOW BIT
    JMP    ERR_RET
READ_WAIT:
    CMP    BX,0FFFFH        ;IF THE TIMEOUT VALUE IS MAX INT,
    JE    RLUP            ;LOOP BACK UP FOREVER
    CALL    GET_CLOCK
    SUB    AX,DX            ;CALCULATE THE DELTA TIME
    NEG    AX
    CMP    AX,BX            ;COMPARE AGAINST THE TIMOUT LIMIT
    JB    RLUP            ;LOOP BACK IF TIME IS STILL OK
    OR    ERVAL[SI],ERITMO    ;TELL THEM A TIMEOUT ERROR HAPPENED
ERR_RET:
    LES    BX,PACKHEAD        ;GET IO PACKET BACK
    SUB    ES:COUNT[BX],CX        ;TELL HIM HOW MANY BYTES MADE IT, AND
    MOV    AX,STSBSY        ;RETURN A READ
    JMP    EXIT            ;FAULT ERROR.
;
SUBTTL    WRITE REQUEST ROUTINE
PAGE
;        OUTPUT DATA TO DEVICE
;
WRITE:
    CALL    GET_CLOCK        ;GET CLOCK VALUE FOR TIMEOUT TEST
    MOV    DX,AX            ;DX WILL CONTAIN STARTING TIME
    MOV    CX,ES:COUNT[BX]        ;GET BYTE COUNT,
    LES    DI,DWORD PTR ES:XFER[BX] ;GET XFER ADDRESS
    MOV    BX,TIMEOUT[SI]        ;GET TIMEOUT LIMIT
WLUP:
    MOV    AL,ES:[DI]    ;GET THE NEXT CHAR DOS SENT YOU
    CALL    PUT_OUT        ;ATTEMPT TO PUT IN IN OUTPUT BUFFER
    CMP    AH,0        ;DID IT WORK?
    JNE    WWAIT        ;NO, GO TEST FOR TIMEOUT
    INC    DI        ;SKIP TO NEXT BYTE
    CALL    START_OUTPUT        ;START THE XMITTER IF NECC.
    LOOP    WLUP            ;YES, GO GET NEXT CHAR.
    MOV    AX,STSDNE        ;RETURN SUCCESS
    JMP    EXIT
WWAIT:
    CALL    GET_CLOCK    ;GET CURRENT CLOCK TIME
    SUB    AX,DX        ;CALCULATE NUMBER OF MILISECONDS SINCE START
    NEG    AX
    CMP    AX,BX        ;HAVE WE WAITED LONG ENUF?
    JB    WLUP        ;NO, KEEP TRYING
    OR    ERVAL[SI],EROTMO    ;TELL THEM OUTPUT TIMED OUT
    LES    BX,PACKHEAD        ;GET IO PACKET BACK
    SUB    ES:COUNT[BX],CX        ;TELL HIM HOW MANY BYTES MADE IT, AND
    MOV    AX,STSBSY        ;YES, RETURN A WRITE FAULT ERROR
    JMP    EXIT
;
SUBTTL    I/O CONTROL READ REQUEST
PAGE
;
;        IOCONTROL READ REQUEST, RETURN INTERNAL STRUCTURE
;
IOCTLIN:
    MOV    CX,ES:COUNT[BX]        ;GET THE REQUESTED NUMBER OF BYTES
    MOV    DI,ES:XFER[BX]        ;DI IS OFFSET TO USER BUFFER
    MOV    DX,ES:XSEG[BX]        ;SEGMENT IS LAST I NEED FROM PACKET,
    MOV    ES,DX            ;NOW ES:DI POINTS TO USER BUFFER.
    CMP    CX,UNIT_SIZE        ;ONLY WORKS WHEN YOU GIVE ME A
    JE    DOIOCIN            ;RIGHT SIZED BUFFER TO STOMP ON.
    MOV    AX,STSERR OR ERRBSL    ;RETURN AN ERROR IF NOT RIGHT.
    JMP    EXIT
DOIOCIN:
    REP MOVSB        ;JUST COPY THE STRUCTURE TO CALLER
    SUB    SI,UNIT_SIZE        ;POINT BACK AT UNIT STRUCTURE
    MOV    AX,0            ;SO YOU CAN ZERO THE
    MOV    ERVAL[SI],AX        ;ERROR WORD EVERY TIME THEY READ IT
    MOV    AX,STSDNE        ;RETURN NO ERRORS
    JMP    EXIT
;
SUBTTL    I/O CONTROL WRITE REQUEST ROUTINE
PAGE
;
;        I USE THIS COMMAND TO COMMUNICATE VARIOUS SPECIAL COMMANDS
;    TO THE DRIVER.  EACH BYTE SENT IS A SEPARATE COMMAND TO FLUSH A
;    BUFFER, CLEAR STATUS, SET SPECIAL FLAGS, ETC.
;
IOCTLOUT:
    MOV    CX,ES:COUNT[BX]        ;GET THE BYTE COUNT
    LES    DI,DWORD PTR ES:XFER[BX] ;AND THE ADDRESS
IOWRITE:        ;LOOP FOR ALL IO CONTROL WRITE BYTES
    MOV    BL,ES:[DI]        ;GET NEXT BYTE
    INC    DI            ;SKIP TO FOLLOWING ONE
    AND    BX,7            ;CHOP OUT LOWER 3 BITS
    SHL    BX,1            ;CONVERT TO WORD INDEX
    CMP    BL,IOWSIZE        ;IS THIS A LEGAL REQUEST?
    JG    IOWERR            ;NO RETURN A WRITE ERROR
    JMP    WORD PTR CS:IOTAB[BX]    ;YES, EXECUTE APPROPRIATE CODE
IOTAB    DW    IOWFLI        ;FLUSH INPUT BUFFER
    DW    IOWFLO        ;FLUSH OUTPUT BUFFER
    DW    IOWTIM        ;SET IO TIMEOUT LIMIT
    DW    IOWSEO        ;SET BYTEWISE MIDI OUTPUT/THRU FLAG
    DW    IOWCLO        ;CLEAR POOR MANS OUTPUT/THRU MERGE FLAG
IOWSIZE    EQU    $-IOTAB

IOWFLI:                ;FLUSH INPUT BUFFER
        ;PUSHF
    CLI            ;CLEAR INTERUPTS WHILE YOU
    MOV    AX,IFIRST[SI]    ;MANIPULATE THE BUFFER POINTERS
    MOV    IAVAIL[SI],AX    ;SET AVAIL EQUAL FIRST TO EMPTY
        STI
    ;POPF            ;ALL DONE AND CLEAR
    MOV    AX,0        ;EVERY TIME YOU FLUSH INPUT BUFFER,
    MOV    ERVAL[SI],AX    ;YOU CAN CLEAR THE ERROR BITS
    DEC    AX        ;AND RESET THE
    MOV    EROFF[SI],AX    ;OFFSET TO ERROR TO AN ILEGAL VALUE
    JMP    IOWNEXT
IOWFLO:                ;FLUSH OUTPUT BUFFER
        ;PUSHF
    CLI            ;CLEAR INTERUPTS WHILE YOU
    MOV    AX,OFIRST[SI]    ;MANIPULATE THE BUFFER POINTERS
    MOV    OAVAIL[SI],AX    ;SET AVAIL EQUAL FIRST TO EMPTY
        STI
       ;POPF            ;ALL DONE AND CLEAR
    JMP    IOWNEXT
IOWTIM:                ;LOAD TIMEOUT LIMIT
    MOV    AX,ES:[DI]    ;GET NEXT WORD FROM INPUT
    ADD    DI,2        ;SKIP WORD IN COMMAND STRING
    SUB    CX,2        ;COUNT THOSE BYTES OUT OF LOOP
    JLE    IOWERR        ;IF THERE WEREN'T ENUF, SCREAM
    MOV    TIMEOUT[SI],AX    ;STORE THEM IN STRUCTURE
    JMP    IOWNEXT
IOWSEO:                ;SET BYTEWISE MIDI OUTPUT/THRU FLAG
    OR    STATUS[SI],OUTHRU    ;SET THE OUT/THRU BIT IN STATUS
    JMP    IOWNEXT
IOWCLO:                ;CLEAR POOR MANS MIDI OPUTPUT/THRU MERGE
    AND    STATUS[SI],NOT OUTHRU    ;CLEAR THE BIT
    JMP    IOWNEXT
IOWNEXT:
    LOOP    IOWRITE        ;LOOP FOR ALL IO CONTROL WRITE BYTES
    MOV    AX,STSDNE    ;RETURN 0 FOR SUCCESS
    JMP    EXIT
IOWERR:            ;I/O CONTROL WRITE ERROR RETURN
    MOV    AX,STSERR OR ERRBSL    ;RETURN WRITE FAULT FOR THESE
    JMP    EXIT


SUBTTL    RING BUFFER ROUTINES
PAGE
;        LOCAL ROUTINES FOR MANAGING THE RING BUFFERS ON INPUT
;    AND OUTPUT.  THE FOLLOWING FOUR ROUTINES ARE ALL CALLED WITH THE
;    SAME CONTEXT:
;
;    DS:SI    POINTS TO THE UNIT STRUCTURE FOR THIS UNIT
;    AL    IS THE CHARACTER TO BE PLACED IN OR REMOVED FROM A BUFFER
;    AH    IS THE RETURN STATUS FLAG: 0=SUCESS, -1=FAILURE
;
;    ALL OTHER REGESTERS ARE PRESERVED.
;
PUT_OUT    PROC    NEAR    ;PUTS AL INTO THE OUTPUT RING BUFFER
    PUSH    CX
    PUSH    DI
    ;PUSHF
    CLI            ;DISABLE INTERUPTS WHILE I HAVE OAVAIL
    MOV    CX,OAVAIL[SI]    ;GET POINTER TO NEXT AVAILABLE BYTE IN
    MOV    DI,CX        ;OUTPUT BUFFER.
    INC    CX        ;INCRIMENT A COPY OF IT TO SEE IF THE
    AND    CX,BUFMSK    ;BUFFER IS FULL.
    CMP    CX,OFIRST[SI]    ;IS IT?
    JE    POERR        ;YES, RETURN AN ERROR
    ADD    DI,OBUF[SI]    ;NO, CALCULATE ACTUAL OFFSET OF CHAR
    MOV    [DI],AL        ;AND STUFF THE CHARACTER INTO BUFFER
    MOV    OAVAIL[SI],CX    ;UPDATE THE POINTER
    MOV    AH,0        ;INDICATE SUCCESS
    JMP    PORET        ;AND RETURN
POERR:
    MOV    AH,-1        ;INDICATE FAILURE.
PORET:
        STI
    ;POPF        ;RE-ENABLE INTERUPTS
    POP    DI
    POP    CX
    RET
PUT_OUT    ENDP

GET_OUT    PROC    NEAR    ;GETS THE NEXT CHARACTER FROM OUTPUT RING BUFFER
            ;SURE YOU DISABLE INTERUPTS FIRST.
    PUSH    CX
    PUSH    DI
    ;PUSHF            ;JUST IN CASE, DISABLE INTERUPTS
    CLI            ;WHILE IN THIS ROUTINE.
    MOV    DI,OFIRST[SI]    ;GET POINTER TO FIRST CHARACTER TO OUTPUT
    CMP    DI,OAVAIL[SI]    ;IS THE BUFFER EMPTY?
    JNE    NGOERR        ;NO.
    MOV    AH,-1        ;YES, INDICATE  FAILURE
    JMP    GORET        ;AND RETURN
NGOERR:
    MOV    CX,DI        ;SAVE A COPY OF THE POINTER
    ADD    DI,OBUF[SI]    ;CALCULATE ACTUAL ADDRESS
    MOV    AL,[DI]        ;GET THE CHAR INTO AL
    MOV    AH,0        ;INDICATE SUCCESS.
    INC    CX        ;INCRIMENT THE OFFSET
    AND    CX,BUFMSK    ;MODULO 128
    MOV    OFIRST[SI],CX    ;STORE BACK IN UNIT TABLE.
GORET:
    ;POPF
        STI
    POP    DI
    POP    CX
    RET
GET_OUT    ENDP

PUT_IN    PROC    NEAR    ;PUT THE CHAR FROM AL INTO INPUT RING BUFFER
    PUSH    CX
    PUSH    DI
    ;PUSHF            ;DISABLE INTS WHILE IN THIS ROUTINE
    CLI
    MOV    DI,IAVAIL[SI]    ;GET POINTER TO NEXT AVAILABLE SLOT IN BUFFER
    MOV    CX,DI        ;SAVE A COPY OF IT,
    INC    CX        ;AND INCRIMENT THAT COPY (MODULO
    AND    CX,BUFMSK        ;128) TO SEE IF THE BUFFER IS FULL.
    CMP    CX,IFIRST[SI]    ;WELL, IS IT?
    JNE    NPIERR        ;NO, THERE`S ROOM.
    MOV    AH,-1        ;YES, INDICATE FAILURE
    JMP    PIRET        ;AND RETURN
NPIERR:
    ADD    DI,IBUF[SI]    ;CALCULATE ACTUAL ADDRES,
    MOV    [DI],AL        ;STORE THE CHARACTER THERE
    MOV    IAVAIL[SI],CX    ;UPDATE THE POINTER.
    MOV    AH,0        ;AND INDICATE SUCCESS.
PIRET:
    ;POPF
        STI
    POP    DI
    POP    CX
    RET
PUT_IN    ENDP

GET_IN    PROC    NEAR    ;GETS ONE CARACTER FROM INPUT RING BUFFER INTO AL
    PUSH    CX
    PUSH    DI
    ;PUSHF
    CLI        ;DISABLE INTERUPTS WHILE I LOOK AT IFIRST.
    MOV    DI,IFIRST[SI]    ;GET POINTER TO FIRST CHAR TO READ
    CMP    DI,IAVAIL[SI]    ;IS THE BUFFER EMPTY?
    JE    GIERR        ;THEN YOU CAN`T VERY WELL SQUEEZE WATER OUT OF IT
    MOV    CX,DI        ;MAKE A COPY OF POINTER,
    ADD    DI,IBUF[SI]    ;CALCULATE ACTUAL ADDRESS OF CHAR
    MOV    AL,[DI]        ;GET THE CHAR INTO AL
    MOV    AH,0        ;INDICATE SUCCESS
    INC    CX        ;INCRIMENT THAT COPY OF YOUR POINTER,
    AND    CX,BUFMSK    ;MODULO THE BUFFER SIZE,
    MOV    IFIRST[SI],CX    ;SO YOU CAN UPDATE THE POINTER.
    JMP    GIRET
GIERR:
    MOV    AH,-1        ;RETURN FAILURE INDICATOR
GIRET:
        STI
    ;POPF        ;RE-ENABLE INTERUPTS BEFORE YOU RETURN
    POP    DI
    POP    CX
    RET
GET_IN    ENDP
SUBTTL    INTERUPT SERVICE ROUTINES
PAGE
;
;         THESE ROUTINES ARE ONLY CALLED WHEN AN INTERUPT IS GENERATED
;    BY THE UART.
;    THESE INTERUPT ROUTINES ARE ENVOKED WHENEVER A CHAR ARRIVES IN THE
;    UART, THE UART FINISHES SENDING A CHARACTER OUT, AN ERROR OCCURS
;    WHILE READING A CHARACTER INTO THE UART.

MIDI_INT:
        PUSH    AX              ;SAVE AX FOR THE USER,
    MOV    AL,020H        ;OUTPUT A 20H TO THE UNDOCUMENTED INTERUPT
    OUT    020H,AL        ;CONTROL CHIP.
        STI                     ;AND LET THE PROCESSOR INTERUPT ME.
    PUSH    BX              ;SAVE THE REST OF THE REGESTERS.
    PUSH    CX
    PUSH    DX
    PUSH    SI
    PUSH    DI
    PUSH    DS    ;SAVE THE DATA SEGMENT
    PUSH    CS    ;SO YOU CAN LOAD CS
    POP    DS    ;INTO DS AND FIND YOUR OWN STRUCTURES.
notify I
;
;    THE FOLLOWING CODE FIGURES OUT WHICH (IF SEVERAL) DAISY-CHAINED
;    DART CHIP FIRED THE INTERUPT, WHICH UART IN THE DART IT WAS,
;    AND THE REASON FOR THE INTERUPT (RECEIVE, XMIT, ERROR).
;
    MOV    CX,MIDI_UNITS    ;GET THE TOTAL NUMBER OF UARTS
    MOV    SI,OFFSET MIDI_TABA    ;ADDRESS OF FIRST UARTS UNIT TABLE
INT_LUP:            ;HEAD OF LOOP TO CHECK ALL UARTS
    MOV    DX,PORT[SI]    ;GET THE PORT ADDRESS
    ADD    DX,MIDCON    ;SLIDE UP TO COMMAND/STATUS REGESTER
    MOV    AL,0        ;MAKE SURE WE ARE TALKING TO REGESTER 0
    OUT    DX,AL
    JMP SHORT $+2
    IN    AL,DX        ;READ REGESTER 0 STATUS
    TEST    AL,INTPEND    ;IS THIS DART CHIP THE ONE?
    JNE    THIS_DART    ;YES, GO ON TO FIND THE PORT
    ADD    SI,UNIT_SIZE*2    ;NO, SKIP TWO UARTS TO NEXT WHOLE DART
    SUB    CX,2
    JG    INT_LUP        ;IF THERE ARE ANY LEFT, KEEP TRYING
    JMP    INT_EXIT    ;IF NOT, YOU'RE IN TROUBLE, BUT I IGNORE
THIS_DART:
    OR    DX,MIDB        ;SLIDE UP TO UART B ON THIS DART
    MOV    AL,2        ;SET UP TO READ REGISTER 2
    OUT    DX,AL
    JMP    SHORT $+2
    IN    AL,DX        ;READ IN VECTOR VALUE
    TEST    AL,VECB        ;WAS THIS INTERUPT CAUSED BY UART B?
    JNE    A_INT        ;NO, IT MUST BE UART A
    DEC    CX        ;YES, MAKE SURE THERE IS A UART B STRUCTURE
    JCXZ    INT_EXIT    ;IGNORE INTERUPTS FROM UNUSED UARTS
    ADD    SI,UNIT_SIZE    ;GET UART B'S UNIT STRUCTURE
    JMP    INT_REASON    ;WE'RE READY TO GO FIND OUT WHY
A_INT:
    AND    DX,MIDA        ;CONVERT PORT NUMBER BACK TO UART A
INT_REASON:
    AND    AX,VECMASK    ;WHACK OUT ONLY THE BITS THAT MATTER
    MOV    BX,AX        ;PUT IT INTO AN INDEX REGESTER
    JMP    INT_FTAB[BX]    ;JUMP TO THE APPROPRIATE ROUTINE
;
INT_FTAB DW    INT_TXMIT    ;TRANSMITTER HOLDING REGESTER EMPTY
    DW    INT_ERROR    ;MODEM LINE INTERUPTS NOT IMPLIMENTED
    DW    INT_RECEIVE    ;RECEIVER BUFFER HAS A CHARACTER
    DW    INT_ERROR    ;RECEIVER FRAMING, OVER-RUN ERROR

INT_ERROR:            ;ENTRYPOINT FOR SETTING BREAKPOINTS
notify E
    NOP            ;FOR ILLEGAL VECTOR VALUES
INT_EXIT:
    MOV    DX,PORT[SI]    ;GET THE PORT NUMBER AGAIN
    ADD    DX,MIDCON    ;CHANGE TO CONTROL PORT
    AND    DX,MIDA        ;MAKE SURE IT'S CHANNEL A OF DART
    MOV    AL,ZREINT    ;SEND THE SIMULATED Z80 RETURN
    OUT    DX,AL        ;FROM INTERUPT COMMAND TO DART
;INTERUPT STUF WAS HERE
        POP    DS    ;RECOVER ALL THE REGESTERS
    POP    DI
    POP    SI
    POP    DX
    POP    CX
    POP    BX
    POP    AX
    IRET
;
;        THE FOLLOWING INTERUPT SERVICE ROUTINES ALL HAVE THE
;    SAME CONTEXT:
;    -CS AND DS POINT TO THE DRIVER SEGMENT.
;    -DS:[SI] POINTS TO THE UNIT STRUCTURE FOR THE ASYNC LINE THAT
;        FIRED THE INTERUPT.
;    -DX POINTS TO THE CONTROL REGESTER OF THE DART
;    -AX BX CX AND DI ARE AVAILABLE FOR SCRATCH.  ALL OTHERS
;        MUST BE LEFT ALONE OR SAVED AND RECOVERED.
;    TO EXIT FROM AN INTERUPT SERVICE ROUTINE, THESE SERVERS MUST
;    JUMP TO INT_EXIT.
;
SUBTTL    RECEIVER INTERUPT SERVICE ROUTINE
PAGE
INT_RECEIVE:    ;THE PORT HAS RECEIVED A NEW CHARACTER, I MUST COPY IT
        ;INTO THE INPUT TYPEAHEAD BUFFER.
notify R
        SUB    DX,MIDCON    ;POINT AT THE DATA REGESTER
    IN    AL,DX        ;GET THE CHARACTER
    CALL    PUT_IN        ;PUT THE CHARACTER IN THE RING BUFFER
    CMP    AH,0        ;WAS THERE ROOM?
    JE    REC_OK        ;NO, SET FLAGS BEFORE RETURNING
notify O
    OR    ERVAL[SI],ERIBFO ;NO, SET THE OVERFLOW BIT
    CMP    EROFF[SI],-1    ;IF YOU HAVN'T INDICATED ANY ERRORS YET
    JNE    REC_OK
    PUSH    AX
    MOV    AX,IAVAIL[SI]    ;THEN INDICATE THE POSITION THAT THE
    MOV    EROFF[SI],AX    ;ERROR HAPPENED
    POP    AX
REC_OK:
    TEST    STATUS[SI],OUTHRU    ;POOR MANS MIDI MERGE TURNED ON?
    JZ    NEXT_REC        ;NOPE, DON'T ECHI THIS CHAR
    CALL    PUT_OUT            ;YUP, SEND THE CHARACTER TO OUTPUT
    CALL    START_OUTPUT        ;AND START THE TRANSMIT IF NECC.
NEXT_REC:            ;CHECK TO SEE IF THERE ARE MORE CHARS READY
    ADD    DX,MIDCON    ;POINT BACK AT THE COMMAND REGESTER
    IN    AL,DX        ;READ REGESTER 0
    TEST    AL,RXCHAR    ;IS THERE ANOTHER CHARACTER READY?
    JNZ    INT_RECEIVE    ;YES, GO READ IT IN ALSO
    MOV    AL,ZRXINT    ;NO, ENABLE INTERUPTS ON NEXT CHAR
    OUT    DX,AL        ;THAT DOES COME IN.
    JMP    INT_EXIT
;
;
SUBTTL    SPECIAL RECEIVE CONDITION INTERUPT
PAGE
;
;        PARITY, FRAMING, OR OVERRUN ERROR INTERUPT
INT_RXSTAT:
notify S
    MOV    AL,1        ;REQUEST READ REGESTER 1
    OUT    DX,AL
    JMP SHORT $+2
    IN    AL,DX        ;READ IN THE VALUE
    AND    AX,070H        ;CHOP OUT THE ERROR BITS
    OR    ERVAL[DI],AX    ;ADD THOSE BITS TO THE ERROR WORD
    CMP    EROFF[SI],-1    ;CHECK TO SEE IF YOU'VE ALREADY
    JNE    RXSTAT_DONE    ;TRAPPED ONE UNREPORTED ERROR
    MOV    AX,IAVAIL[SI]    ;IF NOT, THEN POINT THE
    MOV    EROFF[SI],AX    ;ERROR OFFSET AT NEXT AVAIL BYTE
RXSTAT_DONE:
    MOV    AL,ZERRES    ;RESET THE ERROR BITS IN THE
    OUT    DX,AL        ;UART.
    JMP    INT_EXIT

SUBTTL    TRANSMITTER INTERUPT SERVICE ROUTINE
PAGE
;        THE TRANSMITTER HOLDING REGESTER IS EMPTY, LOOK TO SEE IF
INT_TXMIT:    ;THERE ARE MORE CHARS TO PRINT NOW.
notify T
        AND    STATUS[SI],NOT OUTINT    ;CLEAR INTERUPT EXPECTED BIT.
    CALL    START_OUTPUT        ;START THE NEXT CHARACTER
    MOV    AL,ZTXINT        ;RESET THE UART TRANSMITTER
    OUT    DX,AL            ;PENDING BIT
    JMP    INT_EXIT

;ROUTINE TO START THE NEXT CHARACTER PRINTING ON THE PORT, IF OUTPUT
;IS NOT BEING SUSPENDED FOR ONE REASON OR ANOTHER.
;THIS ROUTINE MAY BE CALLED FROM REQUEST ROUTINES, OR FROM INTERUPT
;SEVICE ROUTINES.
;    THIS ROUTINE DESTROYS AX AND DX.
;    SI MUST POINT AT THE UNIT STRUCTURE.
START_OUTPUT    PROC    NEAR
    ;PUSHF                ;SAVE THE FLAGS SO I CAN
    CLI                ;DISABLE INTERUPTS
    TEST    STATUS[SI],OUTINT    ;AM I IN HOLD OUTPUT MODE?
    JNE    DONT_START        ;YES, DON'T SEND ANY MORE CHARS.
    CALL    GET_OUT        ;CHECK TO SEE IF THERE IS A CHAR IN THE BUF
    CMP    AH,0        ;WELL, WAS THERE?
    JNE    DONT_START    ;NO, BUFFER IS EMPTY
    MOV    DX,PORT[SI]    ;YES, POINT DX AT THE TX OUT REGISTER
    OUT    DX,AL        ;SEND HIM THE CHARACTER
    OR    STATUS[SI],OUTINT        ;WARN EVERYBODY THAT I'M BUSY.
DONT_START:
    ;POPF
        STI
    RET
START_OUTPUT    ENDP
;;
SUBTTL    READ CLOCK CURRENT VALUE
PAGE
;
;        THE GET_CLOCK ROUTINE RETURNS THE CURRENT CLOCK VALUE
;    IN AX.  REGESTER DX IS PRESERVED.
;    This routine returns the "unsullied" clock value, so beware! The
;    timer chip is a count DOWN timer, and you should calculate delta
;    values accordingly.  The C routines that read this clock invert
;    the current value to make it look like an increasing time count,
;    but down here in the driver I left the values raw.
;
GET_CLOCK    PROC    NEAR
    PUSH    DX
    MOV    DX,CLOCK_PORT    ;GET PORT OF CLOCK CHIP
    MOV    AL,T2 OR LATCH    ;TELL HIM YOU WANT TO LATCH TIMER 2
    OUT    DX,AL
    JMP SHORT $+2
    ADD    DX,TIMER2    ;POINT DX AT TIMER2
    IN    AL,DX        ;READ TIMER2 LSB
    JMP SHORT $+2
    MOV    AH,AL
    IN    AL,DX        ;READ TIMER2 MSB
    XCHG    AH,AL        ;SWAP THE BYTES TO NORMAL
    POP    DX
    RET
GET_CLOCK    ENDP
;
;
;        THE FOLLOWING LABEL DEFINES THE END OF THE DRIVER, SO I
;        CAN TELL DOS HOW BIG I AM.
MIDI_END:
SUBTTL    MIDI INITIALIZATION REQUEST ROUTINE
PAGE
;
;        THE INITIALIZE DRIVER ROUTINES ARE STORED AFTER THE "END"
;    OF THE DRIVER HERE SO THAT THIS CODE CAN BE THROWN AWAY AFTER
;    THE DEVICE HAS BEEN INITIALIZED.  THIS CODE IS ONLY CALLED TWICE:
;    ONCE TO INITIALIZE EACH OF THE MIDI UNITS THAT THIS DRIVER
;    CONTAINS.  (APPARENTLY, MSDOS DOESN'T WRITE ANYTHING ON TOP OF
;    THIS CODE UNTIL ALL UNITS ARE INITIALIZED.
;        THE CONTEXT OF THE INITIALIZE CODE BELOW IS THE SAME AS
;    ALL THE OTHER REQUEST ROUTINES EARLIER IN THE DRIVER.
;
INIT_TAB    DB    ZCHANR        ;TABLE OF INITIALIZATION BYTES
        DB    1,W1TXINT OR W1RX1ST OR W1STAT    ;ENABLEL XMITR INTS
        DB    3,W3RXEN OR W3RX8    ;ENABLE RECEIVING, 8 BITS/CHARACTER
        DB    4,W4STOP1 OR W4X64    ;1 STOP BIT, X64 CLOCK MODE
        DB    5,W5TXEN OR W5TX8    ;8 BITS/CHARACTER ON INPUT
        DB    ZRXINT        ;ALLOW NEXT CHAR INPUT TO INTERUPT
INIT_SIZE    EQU    $-INIT_TAB    ;COUNT THE BYTES FOR ME
;
;    TABLE OF REGESTER OFFSETS AND VALUES FOR INITIALIZING THE CLOCK
CLK_TAB    DB    0,T1 OR LMSB OR RATE    ;TIMER ONE IS A RATE GENERATOR
    DB    TIMER1,0,0,8        ;THAT DIVIDES CLOCK BY 2048 (800H)
    DB    -TIMER1,T2 OR LMSB OR RATE ;TIMER TWO IS ALSO A RATE GENERATOR
    DB    TIMER2,0FFH,0,0FFH    ;THAT DIVIDES BY THE LARGEST INT.
    DB    -TIMER2,T3 OR LMSB OR RATE    ;TIMER 3 JUST COUNTS DOWN
    DB    TIMER3,0FFH,0,0FFH    ;FROM LARGEST INTEGER (64K)
CLK_SIZE =    $-CLK_TAB        ;SIZE OF THIS TABLE
;
;        INITIALIZE THE DRIVER AND DEVICE
;
MIDI_INIT:
    MOV    AX,OFFSET MIDI_END    ;GET THE SIZE OF THE DRIVER
    MOV    ES:XFER[BX],AX        ;SEND THAT BACK IN PACKET
    MOV    ES:XSEG[BX],CS        ;SEND THE CODE SEGMENT ALSO.
                ;I HAVE SATISFIED ALL THE REQIREMENTS OF THE
                ;INIT FUNCTION TO RETURN IN THE I/O PACKET, SO
                ;I CAN DESTROY THE CONTENTS OF ES:BX AND USE
                ;THEM FOR OTHER THINGS.
    MOV    DX,PORT[SI]        ;GET THE PORT ADDRESS OF THIS LINE
    ADD    DX,MIDCON        ;SLIDE UP TO THE COMMAND REGESTER
;            THE FOLLOWING CODE INITIALIZES THE Z8470 DART
;            FOR INTERUPT DRIVEN MIDI OPERATION
    MOV    BX,OFFSET INIT_TAB    ;GET ADDRESS OF TABLE
    MOV    CX,INIT_SIZE        ;SIZE OF TABLE
INIT_PORT:
    MOV    AL,[BX]            ;GET NEXT PORT CONTROL BYTE
    OUT    DX,AL            ;SEND IT TO CONTROL REGESTER
    JMP SHORT $+2
    INC    BX            ;INCRIMENT TO NEXT BYTE
    LOOP    INIT_PORT        ;LOOP UNTIL DONE

    TEST    DX,MIDB            ;IF THIS IS UART B OF THE DART,
    JNE    DONE_INIT        ;THEN YOU ARE DONE
            ;ONLY ONCE PER DART IS IT NESESSARY TO INITIALIZE
            ;THE VECTOR IN REGESTER 2
    OR    DX,MIDB            ;SLIDE UP TO UART B
    MOV    AL,2            ;AND THEN INITIALIZE THE
    OUT    DX,AL            ;WRITE REGESTER 2 WITH
    JMP SHORT $+2
    MOV    AL,0            ;A ZERO VECTOR NUMBER
    OUT    DX,AL
            ;IT'S ONLY NECESSARY TO INITIALIZE THE INTERUPT
            ;VECTOR AND MASK ONCE, BUT I ALLOW THE FOLLOWING
            ;CODE TO EXECUTE ONCE FOR EVERY DART CHIP ON YOUR
            ;BOARD.  IT CAN'T HURT.
    MOV    AX,0            ;POINT ES AT THE VECTOR SEGMENT
    MOV    ES,AX            ;SO CAN INITIALIZE THE VECTORS
    MOV    AX,OFFSET MIDI_INT    ;GET ADRS OF INTERUPT SERVICE ROUTINE
    MOV    DI,MIDI_VEC        ;GET ADRS OF VECTOR
    STOS    WORD PTR [DI]        ;STORE THE OFFSET THERE, THEN
    MOV    ES:[DI],CS        ;THE SEGMENT IN THE FOLLOWING WORD.
    MOV    CX,DI            ;CALCULATE THE VECTOR NUMBER:
    SUB    CL,022H            ;SUBTRACT BIAS TO HARDWARE INTS,
    SAR    CL,1            ;DIVIDE BY 4 TO CONVERT TO
    SAR    CL,1            ;HARDWARE INTERUPT NUMBER.
    MOV    AH,1            ;SHIFT A MASK BY THAT MUCH TO
    SAL    AH,CL            ;CREATE INTERUPT ENABLE MASK BIT,
    NOT    AH            ;WHICH IS ACTIVE LOW...
    IN    AL,021H            ;GET SYSTEM HARDWARE INTERUPT MASK
    JMP SHORT $+2
    AND    AL,AH            ;AND MY BIT OUT OF IT,
    OUT    021H,AL            ;WRITE IT BACK OUT AGAIN.
;
;        THIS CODE INITIALIZES THE ON-BOARD CLOCK CHIP TO USEFUL
;    MODES AND RATES FOR MIDI USE.  TIMER1 IS USED TO DIVIDE THE CLOCK
;    PULSE DOWN BY 2048 TO A 1024 TICKS PER SECOND (ABOUT 1 MILISECOND)
;    RATE.  THAT RATE FEEDS TIMER2 WHICH IS THE FIRST CLOCK VALUE READ.
;    FOR LONG DELAY PERIODS, TIMER2 IS ASSUMED TO FEED TIMER3, SO IT
;    WILL CONTAIN THE OVERFLOW, ALLOWING COUNTS UP TO 137 YEARS!
;
    MOV    DX,CLOCK_PORT        ;GET CLOCK CONTROL REGESTER PORT
    MOV    BX,OFFSET CLK_TAB    ;GET ADDRS OF TABLE OF COMMANDS
    MOV    CX,CLK_SIZE/2        ;SEND THIS MANY COMMANDS TO CLOCK
;    SAR    CX,1
CLK_LUP:
    MOV    AL,[BX]            ;GET NEXT REGESTER OFFSET
    CBW
    ADD    DX,AX            ;AND OFFSET FROM IT
    INC    BX            ;SLIDE UP TO NEXT VALUE
    MOV    AL,[BX]            ;GET IT, AND
    INC    BX            ;DON'T FORGET TO SKIP PAST
    OUT    DX,AL            ;SEND VALUE TO CLOCK REGESTER
    LOOP    CLK_LUP
;            THE FOLLOWING LOOP IS SUGESTED BY INTEL IN THE
;            CLOCK CHIP SPEC.'S TO MAKE SURE THE CLOCK HAS
;            SETTLED BEFORE YOU FIRST READ IT.  I ONLY WATCH
;            TIMER2 SETTLE, AND ASSUME THE REST ARE LONG GONE
    MOV    DX,CLOCK_PORT        ;MAKE SURE YOU'RE LOOKING AT CONTROL
CLK_START:
    MOV    AL,T2 OR LATCH        ;LATCH TIMER TWO
    OUT    DX,AL
    JMP SHORT $+2
    ADD    DX,TIMER2        ;SLIDE UP TO IT'S DATA REGESTER
    IN    AL,DX            ;READ AND
    JMP SHORT $+2
    MOV    AH,AL            ;SAVE LEASTMOST BYTE
    IN    AL,DX            ;READ MOST SIGNIFICANT BYTE
    SUB    DX,TIMER2        ;SLIDE BACK TO CONTROL REGESTER
    XCHG    AL,AH            ;MAKE INTO A BINARY NUMBER
    NOT    AX            ;REVERSE INTO A UP-COUNTING NUMBER
    OR    AX,AX            ;AND CHECK FOR ZERO
    JNZ    CLK_START        ;WAIT FOR IT TO SETTLE DOWN
DONE_INIT:
    MOV    AX,STSDNE        ;RETURN NO ERRORS.
    JMP    EXIT

DRIVER    ENDS
    END